Optimering af Pandas DataFrame: Hukommelsesforbrug og Ydelsesjustering

Pandas er et kraftfuldt Python-bibliotek til datamanipulation og -analyse. Men når man arbejder med store datasæt, kan Pandas DataFrames forbruge en betydelig mængde hukommelse og have langsom ydeevne. Denne artikel giver en omfattende guide til optimering af Pandas DataFrames for både hukommelsesforbrug og ydeevne, så du kan behandle større datasæt mere effektivt.

Forståelse af Hukommelsesforbrug i Pandas DataFrames

Før vi dykker ned i optimeringsteknikker, er det afgørende at forstå, hvordan Pandas DataFrames lagrer data i hukommelsen. Hver kolonne i en DataFrame har en specifik datatype, som bestemmer den mængde hukommelse, der kræves for at lagre dens værdier. Almindelige datatyper inkluderer:

• int64: 64-bit heltal (standard for heltal)
• float64: 64-bit flydende kommatal (standard for flydende kommatal)
• object: Python-objekter (bruges til strenge og blandede datatyper)
• category: Kategoriske data (effektivt for gentagne værdier)
• bool: Boolske værdier (True/False)
• datetime64: Datetime-værdier

Datatypen object er ofte den mest hukommelseskrævende, fordi den gemmer henvisninger til Python-objekter, som kan være betydeligt større end primitive datatyper som heltal eller flydende kommatal. Strenge, selv korte, bruger langt mere hukommelse end nødvendigt, når de gemmes som `object`. Tilsvarende er det spild af hukommelse at bruge `int64`, når `int32` ville være tilstrækkeligt.

Eksempel: Inspicering af en DataFrames Hukommelsesforbrug

Du kan bruge metoden memory_usage() til at inspicere hukommelsesforbruget for en DataFrame:

            import pandas as pd
import numpy as np

data = {
    'col1': np.random.randint(0, 1000, 100000),
    'col2': np.random.rand(100000),
    'col3': ['A', 'B', 'C'] * (100000 // 3 + 1)[:100000],
    'col4': ['Dette er en lang streng'] * 100000
}

df = pd.DataFrame(data)

memory_usage = df.memory_usage(deep=True)
print(memory_usage)
print(df.dtypes)

            

              
                Copy
              
            
          

Argumentet deep=True sikrer, at hukommelsesforbruget for objekter (som strenge) beregnes nøjagtigt. Uden `deep=True` vil det kun beregne hukommelsen for henvisningerne, ikke de underliggende data.

Optimering af Datatyper

En af de mest effektive måder at reducere hukommelsesforbruget på er at vælge de mest passende datatyper til dine DataFrame-kolonner. Her er nogle almindelige teknikker:

1. Downcasting af Numeriske Datatyper

Hvis dine heltal- eller flydende kommatalskolonner ikke kræver den fulde rækkevidde af 64-bit præcision, kan du downcaste dem til mindre datatyper som int32, int16, float32 eller float16. Dette kan reducere hukommelsesforbruget betydeligt, især for store datasæt.

Eksempel: Overvej en kolonne, der repræsenterer alder, som sandsynligvis ikke vil overstige 120. At gemme dette som `int64` er spild; `int8` (interval -128 til 127) ville være mere passende.

            def downcast_numeric(df):
    """Downcaster numeriske kolonner til den mindst mulige datatype."""
    for col in df.columns:
        if pd.api.types.is_integer_dtype(df[col]):
            df[col] = pd.to_numeric(df[col], downcast='integer')
        elif pd.api.types.is_float_dtype(df[col]):
            df[col] = pd.to_numeric(df[col], downcast='float')
    return df

df = downcast_numeric(df.copy())
print(df.memory_usage(deep=True))
print(df.dtypes)

            

              
                Copy
              
            
          

Funktionen pd.to_numeric() med argumentet downcast bruges til automatisk at vælge den mindst mulige datatype, der kan repræsentere værdierne i kolonnen. copy() undgår at ændre den oprindelige DataFrame. Kontroller altid værdiområdet i dine data, før du downcaster, for at sikre, at du ikke mister information.

2. Brug af Kategoriske Datatyper

Hvis en kolonne indeholder et begrænset antal unikke værdier, kan du konvertere den til en category-datatype. Kategoriske datatyper gemmer hver unik værdi kun én gang og bruger derefter heltal-koder til at repræsentere værdierne i kolonnen. Dette kan reducere hukommelsesforbruget betydeligt, især for kolonner med en høj andel af gentagne værdier.

Eksempel: Overvej en kolonne, der repræsenterer landekoder. Hvis du arbejder med et begrænset sæt lande (f.eks. kun lande i EU), vil det være meget mere effektivt at gemme dette som en kategori end som strenge.

            def optimize_categories(df):
    """Konverterer objekt-kolonner med lav kardinalitet til kategorisk type."""
    for col in df.columns:
        if df[col].dtype == 'object':
            num_unique_values = len(df[col].unique())
            num_total_values = len(df[col])
            if num_unique_values / num_total_values < 0.5:
                df[col] = df[col].astype('category')
    return df

df = optimize_categories(df.copy())
print(df.memory_usage(deep=True))
print(df.dtypes)

            

              
                Copy
              
            
          

Denne kode tjekker, om antallet af unikke værdier i en objekt-kolonne er mindre end 50% af det samlede antal værdier. Hvis det er tilfældet, konverterer den kolonnen til en kategorisk datatype. Tærsklen på 50% er vilkårlig og kan justeres baseret på de specifikke egenskaber ved dine data. Denne tilgang er mest fordelagtig, når kolonnen indeholder mange gentagne værdier.

3. Undgå Objekt-datatyper til Strenge

Som nævnt tidligere er datatypen object ofte den mest hukommelseskrævende, især når den bruges til at gemme strenge. Hvis det er muligt, så prøv at undgå at bruge object-datatyper til streng-kolonner. Kategoriske typer foretrækkes for strenge med lav kardinalitet. Hvis kardinaliteten er høj, skal du overveje, om strengene kan repræsenteres med numeriske koder, eller om strengdata helt kan undgås.

Hvis du har brug for at udføre strengoperationer på kolonnen, skal du muligvis beholde den som en objekt-type, men overvej, om disse operationer kan udføres på forhånd, hvorefter den konverteres til en mere effektiv type.

4. Dato- og Tidsdata

Brug datetime64-datatypen til dato- og tidsinformation. Sørg for, at opløsningen er passende (nanosekund-opløsning er måske unødvendig). Pandas håndterer tidsseriedata meget effektivt.

Optimering af DataFrame-operationer

Ud over at optimere datatyper kan du også forbedre ydeevnen af Pandas DataFrames ved at optimere de operationer, du udfører på dem. Her er nogle almindelige teknikker:

1. Vektorisering

Vektorisering er processen med at udføre operationer på hele arrays eller kolonner på én gang i stedet for at iterere over individuelle elementer. Pandas er stærkt optimeret til vektoriserede operationer, så brugen af dem kan forbedre ydeevnen betydeligt. Undgå eksplicitte løkker, når det er muligt. Pandas' indbyggede funktioner er generelt meget hurtigere end tilsvarende Python-løkker.

Eksempel: I stedet for at iterere gennem en kolonne for at beregne kvadratet af hver værdi, skal du bruge pow()-funktionen:

            # Ineffektivt (ved brug af en løkke)
import time

start_time = time.time()
results = []
for value in df['col2']:
    results.append(value ** 2)
df['col2_squared_loop'] = results
end_time = time.time()
print(f"Løkke-tid: {end_time - start_time:.4f} sekunder")

# Effektivt (ved brug af vektorisering)
start_time = time.time()
df['col2_squared_vectorized'] = df['col2'] ** 2
end_time = time.time()
print(f"Vektoriseret tid: {end_time - start_time:.4f} sekunder")


            

              
                Copy
              
            
          

Den vektoriserede tilgang er typisk mange gange hurtigere end den løkkebaserede tilgang.

2. Brug af `apply()` med Forsigtighed

Metoden apply() giver dig mulighed for at anvende en funktion på hver række eller kolonne i en DataFrame. Den er dog generelt langsommere end vektoriserede operationer, fordi den involverer kald af en Python-funktion for hvert element. Brug kun apply(), når vektoriserede operationer ikke er mulige.

Hvis du skal bruge `apply()`, så prøv at vektorisere den funktion, du anvender, så meget som muligt. Overvej at bruge Numbas `jit`-dekorator til at kompilere funktionen til maskinkode for betydelige ydeevneforbedringer.

            from numba import jit

@jit(nopython=True)
def my_function(x):
    return x * 2  # Eksempelfunktion

df['col2_applied'] = df['col2'].apply(my_function)

            

              
                Copy
              
            
          

3. Effektiv Valg af Kolonner

Når du vælger et undersæt af kolonner fra en DataFrame, skal du bruge følgende metoder for optimal ydeevne:

• Direkte kolonnevalg: df[['col1', 'col2']] (hurtigst til at vælge få kolonner)
• Boolsk indeksering: df.loc[:, [True if col.startswith('col') else False for col in df.columns]] (nyttigt til at vælge kolonner baseret på en betingelse)

Undgå at bruge df.filter() med regulære udtryk til at vælge kolonner, da det kan være langsommere end andre metoder.

4. Optimering af Joins og Merges

At joine og merge DataFrames kan være beregningsmæssigt dyrt, især for store datasæt. Her er nogle tips til at optimere joins og merges:

• Brug passende join-nøgler: Sørg for, at join-nøglerne har samme datatype og er indekserede.
• Specificer join-typen: Brug den passende join-type (f.eks. inner, left, right, outer) baseret på dine krav. En inner join er generelt hurtigere end en outer join.
• Brug `merge()` i stedet for `join()`: Funktionen merge() er mere alsidig og ofte hurtigere end join()-metoden.

Eksempel:

            df1 = pd.DataFrame({'key': ['A', 'B', 'C', 'D'], 'value1': [1, 2, 3, 4]})
df2 = pd.DataFrame({'key': ['B', 'D', 'E', 'F'], 'value2': [5, 6, 7, 8]})

# Effektiv inner join
df_merged = pd.merge(df1, df2, on='key', how='inner')

print(df_merged)

            

              
                Copy
              
            
          

5. Undgå Unødvendig Kopiering af DataFrames

Mange Pandas-operationer opretter kopier af DataFrames, hvilket kan være hukommelses- og tidskrævende. For at undgå unødvendig kopiering skal du bruge argumentet inplace=True, når det er tilgængeligt, eller tildele resultatet af en operation tilbage til den oprindelige DataFrame. Vær meget forsigtig med `inplace=True`, da det kan skjule fejl og gøre fejlfinding sværere. Det er ofte sikrere at gentildele, selvom det er en anelse mindre performant.

Eksempel:

            # Ineffektivt (opretter en kopi)
df_filtered = df[df['col1'] > 500]

# Effektivt (modificerer den oprindelige DataFrame på stedet - FORSIGTIG)
df.drop(df[df['col1'] <= 500].index, inplace=True)

#SIKRERE - gentildeler, undgår inplace
df = df[df['col1'] > 500]

            

              
                Copy
              
            
          

6. Opdeling i Chunks og Iteration

For ekstremt store datasæt, der ikke kan være i hukommelsen, kan du overveje at behandle dataene i bidder (chunks). Brug chunksize-parameteren, når du læser data fra filer. Iterer gennem bidderne og udfør din analyse på hver bid separat. Dette kræver omhyggelig planlægning for at sikre, at analysen forbliver korrekt, da nogle operationer kræver behandling af hele datasættet på én gang.

            # Læs CSV i chunks
for chunk in pd.read_csv('large_data.csv', chunksize=100000):
    # Behandl hver chunk
    print(chunk.shape)

            

              
                Copy
              
            
          

7. Brug af Dask til Parallel Behandling

Dask er et parallel computing-bibliotek, der integreres problemfrit med Pandas. Det giver dig mulighed for at behandle store DataFrames parallelt, hvilket kan forbedre ydeevnen betydeligt. Dask opdeler DataFrame'en i mindre partitioner og fordeler dem over flere kerner eller maskiner.

            import dask.dataframe as dd

# Opret en Dask DataFrame
ddf = dd.read_csv('large_data.csv')

# Udfør operationer på Dask DataFrame'en
ddf_filtered = ddf[ddf['col1'] > 500]

# Beregn resultatet (dette udløser den parallelle beregning)
result = ddf_filtered.compute()

print(result.head())

            

              
                Copy
              
            
          

Indeksering for Hurtigere Opslag

Oprettelse af et indeks på en kolonne kan markant fremskynde opslags- og filtreringsoperationer. Pandas bruger indekser til hurtigt at finde rækker, der matcher en bestemt værdi.

Eksempel:

            # Sæt 'col3' som indeks
df = df.set_index('col3')

# Hurtigere opslag
value = df.loc['A']

print(value)

# Nulstil indekset
df = df.reset_index()

            

              
                Copy
              
            
          

Dog kan oprettelse af for mange indekser øge hukommelsesforbruget og bremse skriveoperationer. Opret kun indekser på kolonner, der ofte bruges til opslag eller filtrering.

Andre Overvejelser

• Hardware: Overvej at opgradere din hardware (CPU, RAM, SSD), hvis du konsekvent arbejder med store datasæt.
• Software: Sørg for, at du bruger den seneste version af Pandas, da nyere versioner ofte inkluderer ydeevneforbedringer.
• Profilering: Brug profileringsværktøjer (f.eks. cProfile, line_profiler) til at identificere ydeevneflaskehalse i din kode.
• Datalagringsformat: Overvej at bruge mere effektive datalagringsformater som Parquet eller Feather i stedet for CSV. Disse formater er kolonneorienterede og ofte komprimerede, hvilket fører til mindre filstørrelser og hurtigere læse/skrive-tider.

Konklusion

Optimering af Pandas DataFrames for hukommelsesforbrug og ydeevne er afgørende for at arbejde effektivt med store datasæt. Ved at vælge de passende datatyper, bruge vektoriserede operationer og indeksere dine data effektivt, kan du reducere hukommelsesforbruget betydeligt og forbedre ydeevnen. Husk at profilere din kode for at identificere ydeevneflaskehalse og overvej at bruge chunking eller Dask til ekstremt store datasæt. Ved at implementere disse teknikker kan du frigøre det fulde potentiale af Pandas til dataanalyse og -manipulation.